From 01f7f255b5a2bb6407825c0f5dc05ecfe5cffe88 Mon Sep 17 00:00:00 2001 From: Benjamin Otte Date: Wed, 20 Feb 2019 04:53:47 +0100 Subject: [PATCH] gtk: Check return value of compute_bounds() Half of these calls will completely break if anybody ever uses CSS transforms with them, but hey... --- gtk/gtkcontainer.c | 3 +- gtk/gtkentry.c | 8 ++--- gtk/gtkgesturestylus.c | 20 +++++++----- gtk/gtklistbox.c | 12 +++++--- gtk/gtkmenu.c | 4 ++- gtk/gtknotebook.c | 52 ++++++++++++++++--------------- gtk/gtkpaned.c | 3 +- gtk/gtkpopover.c | 8 ++--- gtk/gtkrange.c | 55 ++++++++++++++++++++------------- gtk/gtkscale.c | 7 +++-- gtk/gtkscrolledwindow.c | 3 +- gtk/gtkswitch.c | 4 ++- gtk/gtktooltip.c | 16 +++++++--- gtk/gtktreeviewcolumn.c | 3 +- gtk/gtkwidget.c | 60 +++++++++++++++++++++++------------- gtk/gtkwidgetfocus.c | 16 ++++++---- gtk/gtkwidgetpaintable.c | 19 ++++++++---- gtk/inspector/fpsoverlay.c | 16 +++++----- tests/testwidgettransforms.c | 6 ++-- 19 files changed, 193 insertions(+), 122 deletions(-) diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c index f1ef23e8e4..4c6219ec8a 100644 --- a/gtk/gtkcontainer.c +++ b/gtk/gtkcontainer.c @@ -1653,7 +1653,8 @@ gtk_container_real_set_focus_child (GtkContainer *container, 0, 0, &x, &y)) return; - gtk_widget_compute_bounds (child, child, &child_bounds); + if (!gtk_widget_compute_bounds (child, child, &child_bounds)) + return; if (vadj) gtk_adjustment_clamp_page (vadj, y, y + child_bounds.size.height); diff --git a/gtk/gtkentry.c b/gtk/gtkentry.c index 035b81d828..854410dddf 100644 --- a/gtk/gtkentry.c +++ b/gtk/gtkentry.c @@ -2889,18 +2889,16 @@ gtk_entry_get_icon_area (GtkEntry *entry, { GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry); EntryIconInfo *icon_info; + graphene_rect_t r; g_return_if_fail (GTK_IS_ENTRY (entry)); g_return_if_fail (icon_area != NULL); icon_info = priv->icons[icon_pos]; - if (icon_info) + if (icon_info && + gtk_widget_compute_bounds (icon_info->widget, GTK_WIDGET (entry), &r)) { - graphene_rect_t r; - - gtk_widget_compute_bounds (icon_info->widget, GTK_WIDGET (entry), &r); - *icon_area = (GdkRectangle){ floorf (r.origin.x), floorf (r.origin.y), diff --git a/gtk/gtkgesturestylus.c b/gtk/gtkgesturestylus.c index 4c9d704f6d..2122f08e09 100644 --- a/gtk/gtkgesturestylus.c +++ b/gtk/gtkgesturestylus.c @@ -284,13 +284,19 @@ gtk_gesture_stylus_get_backlog (GtkGestureStylus *gesture, g_array_append_val (backlog_array, *time_coord); time_coord = &g_array_index (backlog_array, GdkTimeCoord, backlog_array->len - 1); - gtk_widget_compute_point (gtk_get_event_widget (event), - gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)), - &GRAPHENE_POINT_INIT (time_coord->axes[GDK_AXIS_X], - time_coord->axes[GDK_AXIS_Y]), - &p); - time_coord->axes[GDK_AXIS_X] = p.x; - time_coord->axes[GDK_AXIS_Y] = p.y; + if (gtk_widget_compute_point (gtk_get_event_widget (event), + gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture)), + &GRAPHENE_POINT_INIT (time_coord->axes[GDK_AXIS_X], + time_coord->axes[GDK_AXIS_Y]), + &p)) + { + time_coord->axes[GDK_AXIS_X] = p.x; + time_coord->axes[GDK_AXIS_Y] = p.y; + } + else + { + g_array_set_size (backlog_array, backlog_array->len - 1); + } } *n_elems = backlog_array->len; diff --git a/gtk/gtklistbox.c b/gtk/gtklistbox.c index 274956d8f8..f6ccfb1931 100644 --- a/gtk/gtklistbox.c +++ b/gtk/gtklistbox.c @@ -1443,7 +1443,9 @@ ensure_row_visible (GtkListBox *box, if (!priv->adjustment) return; - gtk_widget_compute_bounds (GTK_WIDGET (row), GTK_WIDGET (box), &rect); + if (!gtk_widget_compute_bounds (GTK_WIDGET (row), GTK_WIDGET (box), &rect)) + return; + y = rect.origin.y; height = rect.size.height; @@ -1451,9 +1453,11 @@ ensure_row_visible (GtkListBox *box, header = ROW_PRIV (row)->header; if (GTK_IS_WIDGET (header) && gtk_widget_is_drawable (header)) { - gtk_widget_compute_bounds (header, GTK_WIDGET (box), &rect); - y = rect.origin.y; - height += rect.size.height; + if (gtk_widget_compute_bounds (header, GTK_WIDGET (box), &rect)) + { + y = rect.origin.y; + height += rect.size.height; + } } gtk_adjustment_clamp_page (priv->adjustment, y, y + height); diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c index c12b19bcf3..247dd4f12e 100644 --- a/gtk/gtkmenu.c +++ b/gtk/gtkmenu.c @@ -2812,7 +2812,9 @@ definitely_within_item (GtkMenu *menu, int w, h; graphene_rect_t bounds; - gtk_widget_compute_bounds (widget, GTK_WIDGET (menu), &bounds); + if (!gtk_widget_compute_bounds (widget, GTK_WIDGET (menu), &bounds)) + return FALSE; + w = bounds.size.width; h = bounds.size.height; diff --git a/gtk/gtknotebook.c b/gtk/gtknotebook.c index decf8c61cd..af69ab3000 100644 --- a/gtk/gtknotebook.c +++ b/gtk/gtknotebook.c @@ -1628,10 +1628,9 @@ gtk_notebook_get_tab_area_position (GtkNotebook *notebook, if (priv->show_tabs && gtk_notebook_has_current_page (notebook)) { - gtk_widget_compute_bounds (priv->header_widget, - GTK_WIDGET (notebook), - rectangle); - return TRUE; + return gtk_widget_compute_bounds (priv->header_widget, + GTK_WIDGET (notebook), + rectangle); } else { @@ -2094,9 +2093,10 @@ gtk_notebook_get_arrow (GtkNotebook *notebook, if (priv->arrow_widget[i] == NULL) continue; - gtk_widget_compute_bounds (priv->arrow_widget[i], - GTK_WIDGET (notebook), - &arrow_bounds); + if (!gtk_widget_compute_bounds (priv->arrow_widget[i], + GTK_WIDGET (notebook), + &arrow_bounds)) + continue; if (graphene_rect_contains_point (&arrow_bounds, &(graphene_point_t){x, y})) @@ -2184,7 +2184,8 @@ in_tabs (GtkNotebook *notebook, GtkNotebookPrivate *priv = notebook->priv; graphene_rect_t tabs_bounds; - gtk_widget_compute_bounds (priv->tabs_widget, GTK_WIDGET (notebook), &tabs_bounds); + if (!gtk_widget_compute_bounds (priv->tabs_widget, GTK_WIDGET (notebook), &tabs_bounds)) + return FALSE; return graphene_rect_contains_point (&tabs_bounds, &(graphene_point_t){x, y}); @@ -2208,8 +2209,8 @@ get_tab_at_pos (GtkNotebook *notebook, if (!gtk_notebook_page_tab_label_is_visible (page)) continue; - gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &bounds); - + if (!gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &bounds)) + continue; if (graphene_rect_contains_point (&bounds, &(graphene_point_t){x, y})) return children; @@ -2285,10 +2286,14 @@ gtk_notebook_gesture_pressed (GtkGestureMultiPress *gesture, priv->drag_begin_x = priv->mouse_x; priv->drag_begin_y = priv->mouse_y; - gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &tab_bounds); - - priv->drag_offset_x = priv->drag_begin_x - tab_bounds.origin.x; - priv->drag_offset_y = priv->drag_begin_y - tab_bounds.origin.y; + /* tab bounds get set to empty, which is fine */ + priv->drag_offset_x = priv->drag_begin_x; + priv->drag_offset_y = priv->drag_begin_y; + if (gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &tab_bounds)) + { + priv->drag_offset_x -= tab_bounds.origin.x; + priv->drag_offset_y -= tab_bounds.origin.y; + } } } } @@ -2373,10 +2378,9 @@ get_drop_position (GtkNotebook *notebook) y = priv->mouse_y; is_rtl = gtk_widget_get_direction ((GtkWidget *) notebook) == GTK_TEXT_DIR_RTL; - children = priv->children; last_child = NULL; - while (children) + for (children = priv->children; children; children = children->next) { page = children->data; @@ -2387,7 +2391,8 @@ get_drop_position (GtkNotebook *notebook) { graphene_rect_t tab_bounds; - gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &tab_bounds); + if (!gtk_widget_compute_bounds (page->tab_widget, GTK_WIDGET (notebook), &tab_bounds)) + continue; switch (priv->tab_pos) { @@ -2418,8 +2423,6 @@ get_drop_position (GtkNotebook *notebook) last_child = children->next; } - - children = children->next; } return last_child; @@ -2895,10 +2898,10 @@ gtk_notebook_drag_begin (GtkWidget *widget, gtk_widget_unparent (tab_label); priv->dnd_child = tab_label; - gtk_widget_compute_bounds (priv->dnd_child, priv->dnd_child, &bounds); - gtk_widget_set_size_request (priv->dnd_child, - ceilf (bounds.size.width), - ceilf (bounds.size.height)); + if (gtk_widget_compute_bounds (priv->dnd_child, priv->dnd_child, &bounds)) + gtk_widget_set_size_request (priv->dnd_child, + ceilf (bounds.size.width), + ceilf (bounds.size.height)); gtk_style_context_add_class (gtk_widget_get_style_context (priv->dnd_child), "background"); @@ -4933,7 +4936,8 @@ gtk_notebook_calculate_tabs_allocation (GtkNotebook *notebook, break; } - gtk_widget_compute_bounds (priv->cur_page->tab_widget, priv->cur_page->tab_widget, &drag_bounds); + if (!gtk_widget_compute_bounds (priv->cur_page->tab_widget, priv->cur_page->tab_widget, &drag_bounds)) + graphene_rect_init_from_rect (&drag_bounds, graphene_rect_zero ()); left_x = CLAMP (priv->mouse_x - priv->drag_offset_x, allocation->x, allocation->x + allocation->width - drag_bounds.size.width); diff --git a/gtk/gtkpaned.c b/gtk/gtkpaned.c index 2cd216657e..9fc18c9667 100644 --- a/gtk/gtkpaned.c +++ b/gtk/gtkpaned.c @@ -293,7 +293,8 @@ get_handle_area (GtkPaned *paned, GtkPanedPrivate *priv = gtk_paned_get_instance_private (paned); int extra = 0; - gtk_widget_compute_bounds (priv->handle_widget, GTK_WIDGET (paned), area); + if (!gtk_widget_compute_bounds (priv->handle_widget, GTK_WIDGET (paned), area)) + return; if (!gtk_paned_get_wide_handle (paned)) extra = HANDLE_EXTRA_SIZE; diff --git a/gtk/gtkpopover.c b/gtk/gtkpopover.c index 69336460b9..bec65410f0 100644 --- a/gtk/gtkpopover.c +++ b/gtk/gtkpopover.c @@ -338,9 +338,8 @@ gesture_released (GtkGestureMultiPress *gesture, return; child = gtk_bin_get_child (GTK_BIN (popover)); - gtk_widget_compute_bounds (child, GTK_WIDGET (popover), &child_bounds); - - if (!graphene_rect_contains_point (&child_bounds, + if (!gtk_widget_compute_bounds (child, GTK_WIDGET (popover), &child_bounds) || + !graphene_rect_contains_point (&child_bounds, &(graphene_point_t){x, y})) gtk_popover_popdown (popover); } @@ -2147,7 +2146,8 @@ gtk_popover_get_pointing_to (GtkPopover *popover, { graphene_rect_t r; - gtk_widget_compute_bounds (priv->widget, priv->widget, &r); + if (!gtk_widget_compute_bounds (priv->widget, priv->widget, &r)) + return FALSE; rect->x = floorf (r.origin.x); rect->y = floorf (r.origin.y); diff --git a/gtk/gtkrange.c b/gtk/gtkrange.c index 7af7f80a2c..a26e882ec9 100644 --- a/gtk/gtkrange.c +++ b/gtk/gtkrange.c @@ -920,14 +920,19 @@ gtk_range_get_range_rect (GtkRange *range, g_return_if_fail (GTK_IS_RANGE (range)); g_return_if_fail (range_rect != NULL); - gtk_widget_compute_bounds (priv->trough_widget, GTK_WIDGET (range), &r); - - *range_rect = (GdkRectangle) { - floorf (r.origin.x), - floorf (r.origin.y), - ceilf (r.size.width), - ceilf (r.size.height), - }; + if (!gtk_widget_compute_bounds (priv->trough_widget, GTK_WIDGET (range), &r)) + { + *range_rect = (GdkRectangle) { 0, 0, 0, 0 }; + } + else + { + *range_rect = (GdkRectangle) { + floorf (r.origin.x), + floorf (r.origin.y), + ceilf (r.size.width), + ceilf (r.size.height), + }; + } } /** @@ -953,7 +958,14 @@ gtk_range_get_slider_range (GtkRange *range, g_return_if_fail (GTK_IS_RANGE (range)); - gtk_widget_compute_bounds (priv->slider_widget, GTK_WIDGET (range), &slider_bounds); + if (!gtk_widget_compute_bounds (priv->slider_widget, GTK_WIDGET (range), &slider_bounds)) + { + if (slider_start) + *slider_start = 0; + if (slider_end) + *slider_end = 0; + return; + } if (priv->orientation == GTK_ORIENTATION_VERTICAL) { @@ -1745,7 +1757,8 @@ coord_to_value (GtkRange *range, gint slider_length; graphene_rect_t slider_bounds; - gtk_widget_compute_bounds (priv->slider_widget, priv->slider_widget, &slider_bounds); + if (!gtk_widget_compute_bounds (priv->slider_widget, priv->slider_widget, &slider_bounds)) + graphene_rect_init (&slider_bounds, 0, 0, gtk_widget_get_width (priv->trough_widget), gtk_widget_get_height (priv->trough_widget)); if (priv->orientation == GTK_ORIENTATION_HORIZONTAL) { @@ -1804,7 +1817,8 @@ gtk_range_key_controller_key_pressed (GtkEventControllerKey *controller, { graphene_rect_t slider_bounds; - gtk_widget_compute_bounds (priv->slider_widget, priv->trough_widget, &slider_bounds); + if (!gtk_widget_compute_bounds (priv->slider_widget, priv->trough_widget, &slider_bounds)) + return GDK_EVENT_STOP; if (priv->orientation == GTK_ORIENTATION_VERTICAL) priv->slide_initial_slider_position = slider_bounds.origin.y; @@ -1877,7 +1891,6 @@ gtk_range_multipress_gesture_pressed (GtkGestureMultiPress *gesture, guint button; GdkModifierType state_mask; GtkWidget *mouse_location; - graphene_rect_t slider_bounds; if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); @@ -1891,8 +1904,6 @@ gtk_range_multipress_gesture_pressed (GtkGestureMultiPress *gesture, source_device = gdk_event_get_source_device ((GdkEvent *) event); source = gdk_device_get_source (source_device); - gtk_widget_compute_bounds (priv->slider_widget, priv->slider_widget, &slider_bounds); - g_object_get (gtk_widget_get_settings (widget), "gtk-primary-button-warps-slider", &primary_warps, NULL); @@ -1931,13 +1942,15 @@ gtk_range_multipress_gesture_pressed (GtkGestureMultiPress *gesture, (!primary_warps && button == GDK_BUTTON_MIDDLE))) { int slider_range_x, slider_range_y; + graphene_rect_t slider_bounds; gtk_widget_translate_coordinates (priv->trough_widget, widget, priv->slider_x, priv->slider_y, &slider_range_x, &slider_range_y); /* If we aren't fixed, center on the slider. I.e. if this is not a scale... */ - if (!priv->slider_size_fixed) + if (!priv->slider_size_fixed && + gtk_widget_compute_bounds (priv->slider_widget, priv->slider_widget, &slider_bounds)) { slider_range_x += (slider_bounds.size.width / 2); slider_range_y += (slider_bounds.size.height / 2); @@ -2012,6 +2025,7 @@ update_slider_position (GtkRange *range, gint mouse_y) { GtkRangePrivate *priv = gtk_range_get_instance_private (range); + graphene_rect_t trough_bounds; gdouble delta; gdouble c; gdouble new_value; @@ -2025,17 +2039,15 @@ update_slider_position (GtkRange *range, gtk_widget_translate_coordinates (GTK_WIDGET (range), priv->trough_widget, mouse_x, mouse_y, &mouse_x, &mouse_y); - if (priv->zoom) + if (priv->zoom && + gtk_widget_compute_bounds (priv->trough_widget, priv->trough_widget, &trough_bounds)) { - graphene_rect_t trough_bounds; - - gtk_widget_compute_bounds (priv->trough_widget, priv->trough_widget, &trough_bounds); - zoom = MIN(1.0, (priv->orientation == GTK_ORIENTATION_VERTICAL ? trough_bounds.size.height : trough_bounds.size.width) / (gtk_adjustment_get_upper (priv->adjustment) - gtk_adjustment_get_lower (priv->adjustment) - gtk_adjustment_get_page_size (priv->adjustment))); + /* the above is ineffective for scales, so just set a zoom factor */ if (zoom == 1.0) zoom = 0.25; @@ -2048,7 +2060,8 @@ update_slider_position (GtkRange *range, { graphene_rect_t slider_bounds; - gtk_widget_compute_bounds (priv->slider_widget, GTK_WIDGET (range), &slider_bounds); + if (!gtk_widget_compute_bounds (priv->slider_widget, GTK_WIDGET (range), &slider_bounds)) + graphene_rect_init (&slider_bounds, 0, 0, 0, 0); if (priv->orientation == GTK_ORIENTATION_VERTICAL) priv->slide_initial_slider_position = (zoom * (mouse_y - priv->slide_initial_coordinate_delta) - slider_bounds.origin.y) / (zoom - 1.0); diff --git a/gtk/gtkscale.c b/gtk/gtkscale.c index 9d3673e715..29607a9cca 100644 --- a/gtk/gtkscale.c +++ b/gtk/gtkscale.c @@ -336,7 +336,8 @@ gtk_scale_allocate_value (GtkScale *scale) range_height = gtk_widget_get_height (widget); slider_widget = gtk_range_get_slider_widget (range); - gtk_widget_compute_bounds (slider_widget, widget, &slider_bounds); + if (!gtk_widget_compute_bounds (slider_widget, widget, &slider_bounds)) + graphene_rect_init (&slider_bounds, 0, 0, gtk_widget_get_width (widget), gtk_widget_get_height (widget)); gtk_widget_measure (priv->value_widget, GTK_ORIENTATION_HORIZONTAL, -1, @@ -1519,7 +1520,8 @@ gtk_scale_real_get_layout_offsets (GtkScale *scale, GtkScalePrivate *priv = gtk_scale_get_instance_private (scale); graphene_rect_t value_bounds; - if (!priv->value_widget) + if (!priv->value_widget || + !gtk_widget_compute_bounds (priv->value_widget, GTK_WIDGET (scale), &value_bounds)) { *x = 0; *y = 0; @@ -1527,7 +1529,6 @@ gtk_scale_real_get_layout_offsets (GtkScale *scale, return; } - gtk_widget_compute_bounds (priv->value_widget, GTK_WIDGET (scale), &value_bounds); *x = value_bounds.origin.x; *y = value_bounds.origin.y; diff --git a/gtk/gtkscrolledwindow.c b/gtk/gtkscrolledwindow.c index 8e8f78e35b..ea1b402c4b 100644 --- a/gtk/gtkscrolledwindow.c +++ b/gtk/gtkscrolledwindow.c @@ -1046,7 +1046,8 @@ coords_close_to_indicator (GtkScrolledWindow *sw, graphene_rect_t indicator_bounds; gint distance; - gtk_widget_compute_bounds (indicator->scrollbar, GTK_WIDGET (sw), &indicator_bounds); + if (!gtk_widget_compute_bounds (indicator->scrollbar, GTK_WIDGET (sw), &indicator_bounds)) + return FALSE; if (indicator->over) distance = INDICATOR_FAR_DISTANCE; diff --git a/gtk/gtkswitch.c b/gtk/gtkswitch.c index 4bdfb5094f..eefa49c708 100644 --- a/gtk/gtkswitch.c +++ b/gtk/gtkswitch.c @@ -191,7 +191,9 @@ gtk_switch_multipress_gesture_pressed (GtkGestureMultiPress *gesture, GtkSwitchPrivate *priv = gtk_switch_get_instance_private (sw); graphene_rect_t switch_bounds; - gtk_widget_compute_bounds (GTK_WIDGET (sw), GTK_WIDGET (sw), &switch_bounds); + if (!gtk_widget_compute_bounds (GTK_WIDGET (sw), GTK_WIDGET (sw), &switch_bounds)) + return; + gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED); /* If the press didn't happen in the draggable handle, diff --git a/gtk/gtktooltip.c b/gtk/gtktooltip.c index 22fafbf47b..592d56d88a 100644 --- a/gtk/gtktooltip.c +++ b/gtk/gtktooltip.c @@ -585,11 +585,17 @@ gtk_tooltip_position (GtkTooltip *tooltip, tooltip->tooltip_widget = new_tooltip_widget; toplevel = _gtk_widget_get_toplevel (new_tooltip_widget); - gtk_widget_compute_bounds (new_tooltip_widget, toplevel, &anchor_bounds); - anchor_rect = (GdkRectangle) { - floorf (anchor_bounds.origin.x), floorf (anchor_bounds.origin.y), - ceilf (anchor_bounds.size.width), ceilf (anchor_bounds.size.height) - }; + if (gtk_widget_compute_bounds (new_tooltip_widget, toplevel, &anchor_bounds)) + { + anchor_rect = (GdkRectangle) { + floorf (anchor_bounds.origin.x), floorf (anchor_bounds.origin.y), + ceilf (anchor_bounds.size.width), ceilf (anchor_bounds.size.height) + }; + } + else + { + anchor_rect = (GdkRectangle) { 0, 0, 0, 0 }; + } settings = gtk_settings_get_for_display (display); g_object_get (settings, diff --git a/gtk/gtktreeviewcolumn.c b/gtk/gtktreeviewcolumn.c index aa730c8f9b..674cb7696b 100644 --- a/gtk/gtktreeviewcolumn.c +++ b/gtk/gtktreeviewcolumn.c @@ -3060,7 +3060,8 @@ _gtk_tree_view_column_coords_in_resize_rect (GtkTreeViewColumn *column, !priv->visible) return FALSE; - gtk_widget_compute_bounds (priv->button, priv->tree_view, &button_bounds); + if (!gtk_widget_compute_bounds (priv->button, priv->tree_view, &button_bounds)) + return FALSE; if (gtk_widget_get_direction (priv->tree_view) == GTK_TEXT_DIR_LTR) button_bounds.origin.x += button_bounds.size.width - TREE_VIEW_DRAG_WIDTH; diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c index 21a1ff3333..ab2f219551 100644 --- a/gtk/gtkwidget.c +++ b/gtk/gtkwidget.c @@ -2544,10 +2544,11 @@ _gtk_widget_emulate_press (GtkWidget *widget, return; gdk_event_get_coords (event, &x, &y); - gtk_widget_compute_point (event_widget, - gtk_widget_get_toplevel (event_widget), - &GRAPHENE_POINT_INIT (x, y), - &p); + if (!gtk_widget_compute_point (event_widget, + gtk_widget_get_toplevel (event_widget), + &GRAPHENE_POINT_INIT (x, y), + &p)) + return; if (event->any.type == GDK_TOUCH_BEGIN || event->any.type == GDK_TOUCH_UPDATE || @@ -3863,13 +3864,19 @@ gtk_widget_get_surface_allocation (GtkWidget *widget, g_assert (GTK_IS_WINDOW (parent) || GTK_IS_POPOVER (parent)); - gtk_widget_compute_bounds (widget, parent, &bounds); - *allocation = (GtkAllocation){ - floorf (bounds.origin.x), - floorf (bounds.origin.y), - ceilf (bounds.size.width), - ceilf (bounds.size.height) - }; + if (gtk_widget_compute_bounds (widget, parent, &bounds)) + { + *allocation = (GtkAllocation){ + floorf (bounds.origin.x), + floorf (bounds.origin.y), + ceilf (bounds.size.width), + ceilf (bounds.size.height) + }; + } + else + { + *allocation = (GtkAllocation) { 0, 0, 0, 0 }; + } } static void @@ -5120,9 +5127,9 @@ _gtk_widget_run_controllers (GtkWidget *widget, return handled; } -static void +static gboolean translate_event_coordinates (GdkEvent *event, - GtkWidget *widget); + GtkWidget *widget); gboolean _gtk_widget_captured_event (GtkWidget *widget, const GdkEvent *event) @@ -5138,7 +5145,11 @@ _gtk_widget_captured_event (GtkWidget *widget, return TRUE; event_copy = gdk_event_copy (event); - translate_event_coordinates (event_copy, widget); + if (!translate_event_coordinates (event_copy, widget)) + { + g_object_unref (event_copy); + return FALSE; + } return_val = _gtk_widget_run_controllers (widget, event_copy, GTK_PHASE_CAPTURE); @@ -5196,7 +5207,7 @@ event_surface_is_still_viewable (const GdkEvent *event) } } -static void +static gboolean translate_event_coordinates (GdkEvent *event, GtkWidget *widget) { @@ -5205,16 +5216,19 @@ translate_event_coordinates (GdkEvent *event, graphene_point_t p; if (!gdk_event_get_coords (event, &x, &y)) - return; + return TRUE; event_widget = gtk_get_event_widget (event); - gtk_widget_compute_point (event_widget, - widget, - &GRAPHENE_POINT_INIT (x, y), - &p); + if (!gtk_widget_compute_point (event_widget, + widget, + &GRAPHENE_POINT_INIT (x, y), + &p)) + return FALSE; gdk_event_set_coords (event, p.x, p.y); + + return TRUE; } static gboolean @@ -5237,7 +5251,11 @@ gtk_widget_event_internal (GtkWidget *widget, event_copy = gdk_event_copy (event); - translate_event_coordinates (event_copy, widget); + if (!translate_event_coordinates (event_copy, widget)) + { + g_object_unref (event_copy); + return FALSE; + } if (widget == gtk_get_event_target (event_copy)) return_val |= _gtk_widget_run_controllers (widget, event_copy, GTK_PHASE_TARGET); diff --git a/gtk/gtkwidgetfocus.c b/gtk/gtkwidgetfocus.c index 79177311d4..af68bd7a56 100644 --- a/gtk/gtkwidgetfocus.c +++ b/gtk/gtkwidgetfocus.c @@ -80,8 +80,9 @@ tab_sort_func (gconstpointer a, GtkTextDirection text_direction = GPOINTER_TO_INT (user_data); float y1, y2; - gtk_widget_compute_bounds (child1, gtk_widget_get_parent (child1), &child_bounds1); - gtk_widget_compute_bounds (child2, gtk_widget_get_parent (child2), &child_bounds2); + if (!gtk_widget_compute_bounds (child1, gtk_widget_get_parent (child1), &child_bounds1) || + !gtk_widget_compute_bounds (child2, gtk_widget_get_parent (child2), &child_bounds2)) + return 0; y1 = child_bounds1.origin.y + (child_bounds1.size.height / 2.0f); y2 = child_bounds2.origin.y + (child_bounds2.size.height / 2.0f); @@ -178,8 +179,9 @@ axis_compare (gconstpointer a, int start1, end1; int start2, end2; - gtk_widget_compute_bounds (*((GtkWidget **)a), compare->widget, &bounds1); - gtk_widget_compute_bounds (*((GtkWidget **)b), compare->widget, &bounds2); + if (!gtk_widget_compute_bounds (*((GtkWidget **)a), compare->widget, &bounds1) || + !gtk_widget_compute_bounds (*((GtkWidget **)b), compare->widget, &bounds2)) + return 0; get_axis_info (&bounds1, compare->axis, &start1, &end1); get_axis_info (&bounds2, compare->axis, &start2, &end2); @@ -278,7 +280,8 @@ focus_sort_left_right (GtkWidget *widget, graphene_rect_t old_focus_bounds; parent = gtk_widget_get_parent (widget); - gtk_widget_compute_bounds (widget, parent ? parent : widget, &bounds); + if (!gtk_widget_compute_bounds (widget, parent ? parent : widget, &bounds)) + graphene_rect_init (&bounds, 0, 0, 0, 0); if (old_focus_coords (widget, &old_focus_bounds)) { @@ -379,7 +382,8 @@ focus_sort_up_down (GtkWidget *widget, graphene_rect_t old_focus_bounds; parent = gtk_widget_get_parent (widget); - gtk_widget_compute_bounds (widget, parent ? parent : widget, &bounds); + if (!gtk_widget_compute_bounds (widget, parent ? parent : widget, &bounds)) + graphene_rect_init (&bounds, 0, 0, 0, 0); if (old_focus_coords (widget, &old_focus_bounds)) { diff --git a/gtk/gtkwidgetpaintable.c b/gtk/gtkwidgetpaintable.c index 531b1332fc..23a359d204 100644 --- a/gtk/gtkwidgetpaintable.c +++ b/gtk/gtkwidgetpaintable.c @@ -96,11 +96,17 @@ gtk_widget_paintable_paintable_snapshot (GdkPaintable *paintable, gtk_snapshot_push_clip (snapshot, &GRAPHENE_RECT_INIT(0, 0, width, height)); - gtk_widget_compute_bounds (self->widget, self->widget, &bounds); - graphene_matrix_init_from_2d (&transform, - width / bounds.size.width, 0.0, - 0.0, height / bounds.size.height, - bounds.origin.x, bounds.origin.y); + if (gtk_widget_compute_bounds (self->widget, self->widget, &bounds)) + { + graphene_matrix_init_from_2d (&transform, + width / bounds.size.width, 0.0, + 0.0, height / bounds.size.height, + bounds.origin.x, bounds.origin.y); + } + else + { + graphene_matrix_init_identity (&transform); + } gtk_snapshot_push_transform (snapshot, &transform); gtk_widget_snapshot (self->widget, snapshot); @@ -269,7 +275,8 @@ gtk_widget_paintable_snapshot_widget (GtkWidgetPaintable *self) if (self->widget == NULL) return gdk_paintable_new_empty (0, 0); - gtk_widget_compute_bounds (self->widget, self->widget, &bounds); + if (!gtk_widget_compute_bounds (self->widget, self->widget, &bounds)) + return gdk_paintable_new_empty (0, 0); if (self->widget->priv->render_node == NULL) return gdk_paintable_new_empty (bounds.size.width, bounds.size.height); diff --git a/gtk/inspector/fpsoverlay.c b/gtk/inspector/fpsoverlay.c index 07ff181dd3..616781e7b1 100644 --- a/gtk/inspector/fpsoverlay.c +++ b/gtk/inspector/fpsoverlay.c @@ -158,6 +158,7 @@ gtk_fps_overlay_snapshot (GtkInspectorOverlay *overlay, double fps; char *fps_string; graphene_rect_t bounds; + gboolean has_bounds; int width, height; double overlay_opacity; @@ -202,20 +203,20 @@ gtk_fps_overlay_snapshot (GtkInspectorOverlay *overlay, if (GTK_IS_WINDOW (widget)) { GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget)); - if (child) - gtk_widget_compute_bounds (child, widget, &bounds); - else - gtk_widget_compute_bounds (widget, widget, &bounds); + if (!child || + !gtk_widget_compute_bounds (child, widget, &bounds)) + has_bounds = gtk_widget_compute_bounds (widget, widget, &bounds); } else { - gtk_widget_compute_bounds (widget, widget, &bounds); + has_bounds = gtk_widget_compute_bounds (widget, widget, &bounds); } layout = gtk_widget_create_pango_layout (widget, fps_string); pango_layout_get_pixel_size (layout, &width, &height); - gtk_snapshot_offset (snapshot, bounds.origin.x + bounds.size.width - width, bounds.origin.y); + if (has_bounds) + gtk_snapshot_offset (snapshot, bounds.origin.x + bounds.size.width - width, bounds.origin.y); if (overlay_opacity < 1.0) gtk_snapshot_push_opacity (snapshot, overlay_opacity); gtk_snapshot_append_color (snapshot, @@ -226,7 +227,8 @@ gtk_fps_overlay_snapshot (GtkInspectorOverlay *overlay, &(GdkRGBA) { 1, 1, 1, 1 }); if (overlay_opacity < 1.0) gtk_snapshot_pop (snapshot); - gtk_snapshot_offset (snapshot, - bounds.origin.x - bounds.size.width + width, - bounds.origin.y); + if (has_bounds) + gtk_snapshot_offset (snapshot, - bounds.origin.x - bounds.size.width + width, - bounds.origin.y); g_free (fps_string); gtk_widget_add_tick_callback (widget, gtk_fps_overlay_force_redraw, NULL, NULL); diff --git a/tests/testwidgettransforms.c b/tests/testwidgettransforms.c index 65c78825cc..9200335cdb 100644 --- a/tests/testwidgettransforms.c +++ b/tests/testwidgettransforms.c @@ -153,10 +153,10 @@ gtk_transform_tester_snapshot (GtkWidget *widget, GTK_WIDGET_CLASS (gtk_transform_tester_parent_class)->snapshot (widget, snapshot); - if (!do_picking) + if (!do_picking || + !gtk_widget_compute_bounds (self->test_widget, widget, &child_bounds) || + !gtk_widget_compute_bounds (self->test_widget, self->test_widget, &self_bounds)) return; - gtk_widget_compute_bounds (self->test_widget, widget, &child_bounds); - gtk_widget_compute_bounds (self->test_widget, self->test_widget, &self_bounds); { const struct { -- 2.30.2